Sommaire (esilv_tp2_pandas_accidents_de_la_route)

-1) Base de données accidents corporels de la circulation
-1.1) Téléchargement de la documentation

0) Téléchargements des données

1) Matplotlib : la librairie standard est originale de python

1.1) Syntaxe d'extraction d'élèments en fin ou début de tableau => [:]

2) Bokeh : la nouvelle librairie d'analyse de données

3) Modification des noms de colonnes

3.1) méthode 1
3.2) méthode 2

4) analyse

4.1) passer de catégories chiffrées à des labels
4.2) group by / count / unique
4.3) scatter plot : matplotlib / bokeh

5) Analyse des départements

5.1) Gestion des nuls
5.2) Regardons les départements
5.3) Tableau croisé dynamique
5.4) seaborn
5.4.1) heatmap

6) pickeliser les dataframes :

7) Formattage des strings en python

7.1) Version historique : %S
7.2) Les accolades + la fonction format
7.3) f-strings

-1) Base de données accidents corporels de la circulation

https://www.data.gouv.fr/fr/datasets/base-de-donnees-accidents-corporels-de-la-circulation/

Ce jeu de données provient d'un service public certifié NEC MERGITUR Pour chaque accident corporel (soit un accident survenu sur une voie ouverte à la circulation publique, impliquant au moins un véhicule et ayant fait au moins une victime ayant nécessité des soins), des saisies d’information décrivant l’accident sont effectuées par l’unité des forces de l’ordre (police, gendarmerie, etc.) qui est intervenue sur le lieu de l’accident. Ces saisies sont rassemblées dans une fiche intitulée bulletin d’analyse des accidents corporels. L’ensemble de ces fiches constitue le fichier national des accidents corporels de la circulation dit " Fichier BAAC " administré par l’Observatoire national interministériel de la sécurité routière "ONISR".

Les bases de données, extraites du fichier BAAC, répertorient l'intégralité des accidents corporels de la circulation intervenus durant une année précise en France métropolitaine ainsi que les départements d’Outre-mer (Guadeloupe, Guyane, Martinique, La Réunion et Mayotte depuis 2012) avec une description simplifiée. Cela comprend des informations de localisation de l’accident, telles que renseignées ainsi que des informations concernant les caractéristiques de l’accident et son lieu, les véhicules impliqués et leurs victimes.

Par rapport aux bases de données agrégées 2005-2010 et 2006-2011 actuellement disponibles sur le site www.data.gouv.fr, les bases de données de 2005 à 2016 sont désormais annuelles et composées de 4 fichiers (Caractéristiques – Lieux – Véhicules – Usagers ) au format csv.

Ces bases occultent néanmoins certaines données spécifiques relatives aux usagers et aux véhicules et à leur comportement dans la mesure où la divulgation de ces données porterait atteinte à la protection de la vie privée des personnes physiques aisément identifiables ou ferait apparaître le comportement de telles personnes alors que la divulgation de ce comportement pourrait leur porter préjudice (avis de la CADA – 2 janvier 2012).

%matplotlib inline

import pandas as pd

-1.1) Téléchargement de la documentation

https://www.data.gouv.fr/fr/datasets/r/36496bab-a042-47bf-b08b-3c7467f2bddf

0) Téléchargements des données

https://www.data.gouv.fr/fr/datasets/r/be2191a6-a7cd-446f-a9fc-8d698688eb9e

https://www.data.gouv.fr/fr/datasets/r/e4c6f4fe-7c68-4a1d-9bb6-b0f1f5d45526

https://www.data.gouv.fr/fr/datasets/r/08b77510-39c4-4761-bf02-19457264790f

https://www.data.gouv.fr/fr/datasets/r/96aadc9f-0b55-4e9a-a70e-c627ed97e6f7

import pandas as pd

types_des_colonnes ={"hrmn" : str }

df = pd.read_csv("caracteristiques_2016.csv", encoding="latin1", dtype=types_des_colonnes)

df.head()

	Num_Acc	an	mois	jour	hrmn	lum	agg	int	atm	col	com	adr	gps	lat	long	dep
0	201600000001	16	2	1	1445	1	2	1	8	3.0	5	46, rue Sonneville	M	0.0	0.0	590
1	201600000002	16	3	16	1800	1	2	6	1	6.0	5	1a rue du cimetière	M	0.0	0.0	590
2	201600000003	16	7	13	1900	1	1	1	1	6.0	11	NaN	M	0.0	0.0	590
3	201600000004	16	8	15	1930	2	2	1	7	3.0	477	52 rue victor hugo	M	0.0	0.0	590
4	201600000005	16	12	23	1100	1	2	3	1	3.0	11	rue Joliot curie	M	0.0	0.0	590

df.dtypes

Num_Acc      int64
an           int64
mois         int64
jour         int64
hrmn        object
lum          int64
agg          int64
int          int64
atm          int64
col        float64
com          int64
adr         object
gps         object
lat        float64
long       float64
dep          int64
dtype: object

def make_string_4_car(string):
    """
    Rajoute des 0 devant une chaine de caractère si elle a moins de 4 caractères
    """
    while len(string)<4:
        string = "0" + string
    return string

def test_make_string_4_car():
    """
    Exemple de Test-Driven-Developement : comment faire un test de fonctions
    """
    function = make_string_4_car
    input_ = "4"
    expected_output = "0004"
    assert(function(input_) == expected_output)
    
    input_ = "0004"
    expected_output = "0004"
    assert(function(input_) == expected_output)
    
test_make_string_4_car()

df.hrmn = df.hrmn.map(make_string_4_car)

1) Matplotlib : la librairie standard est originale de python

title = "Nombre d'accidents par heure:min de la journée"
_ = df.groupby("hrmn")["Num_Acc"].count()
_.plot(title=title, figsize=(30,10))

<AxesSubplot:title={'center':"Nombre d'accidents par heure:min de la journée"}, xlabel='hrmn'>

1.1) Syntaxe d'extraction d'élèments en fin ou début de tableau => [:]

"ceci est un tableau de caractères"[-2:]

'es'

"ceci est un tableau de caractères"[:-2]

'ceci est un tableau de caractèr'

df["is_in_quart_d_heure"] = df.hrmn.map(lambda x: x[-2:] in ["00", "15", "30", "45"])

df["is_in_quart_d_heure"]

0        45
1        00
2        00
3        30
4        00
         ..
59427    01
59428    15
59429    10
59430    05
59431    35
Name: is_in_quart_d_heure, Length: 59432, dtype: object

df.is_in_quart_d_heure.sum()

33916

2) Bokeh : la nouvelle librairie d'analyse de données

from bokeh.plotting import figure, show
from bokeh.io import output_notebook
from bokeh.transform import linear_cmap
from bokeh.palettes import Spectral6
output_notebook()

Loading BokehJS ...

_       = df.groupby("hrmn")["Num_Acc"].count()
_2      = _.reset_index()
_2.hrmn = _2.hrmn.map(int)

_2

	hrmn	Num_Acc
0	1	141
1	2	6
2	3	2
3	4	3
4	5	66
...	...	...
1307	2355	40
1308	2356	2
1309	2357	3
1310	2358	1
1311	2359	3

1312 rows × 2 columns

_ .head(5)

hrmn
0001    141
0002      6
0003      2
0004      3
0005     66
Name: Num_Acc, dtype: int64

_2 .head(20)

	hrmn	Num_Acc
0	1	141
1	2	6
2	3	2
3	4	3
4	5	66
5	6	2
6	7	3
7	8	3
8	9	3
9	10	81
10	11	1
11	12	2
12	13	4
13	14	2
14	15	125
15	16	2
16	17	1
17	19	1
18	20	68
19	21	1

_2.hrmn.map?

_2.hrmn.head(5)

0    1
1    2
2    3
3    4
4    5
Name: hrmn, dtype: int64

#x_y          = ("(x,y)" , "($x, $y)")
#hrmn_num_Acc = ("hrmn, num_acc", "@hrmn : @Num_Acc")

linear_cmap?

mapper = linear_cmap(field_name = "Num_Acc", 
                     palette    = Spectral6 , 
                     low        = min(_2.Num_Acc) ,
                     high       = max(_2.Num_Acc))

p = figure()
p.circle(x="hrmn", y="Num_Acc", source=_2, color=mapper)
show(p)

3) Modification des noms de colonnes

df.columns

Index(['Num_Acc', 'an', 'mois', 'jour', 'hrmn', 'lum', 'agg', 'int', 'atm',
       'col', 'com', 'adr', 'gps', 'lat', 'long', 'dep',
       'is_in_quart_d_heure'],
      dtype='object')

3.1) méthode 1

nouvelles_colonnes = ["Num_Acc", "an", "mois", "jour", "hrmn", 
                      "lumiere", "agglomeration", "intersection", 
                      "meteo", 'collision', 'num_commune', 'adr', 
                      'gps', 'lat', 'long', 'dep', "is_in_quart_d_heure"]

df.columns = nouvelles_colonnes

df.sample().T

	28111
Num_Acc	201600028112
an	16
mois	5
jour	5
hrmn	1145
lumiere	1
agglomeration	2
intersection	6
meteo	1
collision	3
num_commune	147
adr	GEOFFROY DE MONTBRAY
gps	M
lat	4.90396e+06
long	-144733
dep	500
is_in_quart_d_heure	True

3.2) méthode 2

colonnes_a_changer = {"lat" :"lattitude", "long" : "longitude"}
df.rename(columns=colonnes_a_changer, inplace=True)

4) analyse

# les num acc sont ils uniques ? 
df.Num_Acc.is_unique

True

# nombre d'accidents par typologie meteo
df.groupby("meteo")["Num_Acc"].count().sort_values()

meteo
6      144
4      159
9      300
5      621
7      667
3     1422
8     1640
2     6582
1    47897
Name: Num_Acc, dtype: int64

4.1) passer de catégories chiffrées à des labels

label_meteo = {
1 : "Normale",
2 : "Pluie légère",
3 : "Pluie forte",
4 : "Neige - grêle",
5 : "Brouillard - fumée",
6 : "Vent fort - tempête",
7 : "Temps éblouissant",
8 : "Temps couvert",
9 : "Autre",}

label_meteo

{1: 'Normale',
 2: 'Pluie légère',
 3: 'Pluie forte',
 4: 'Neige - grêle',
 5: 'Brouillard - fumée',
 6: 'Vent fort - tempête',
 7: 'Temps éblouissant',
 8: 'Temps couvert',
 9: 'Autre'}

df["label_meteo"] = df.meteo.map(label_meteo)

df.sample(3).T

	13522	53400	21484
Num_Acc	201600013523	201600053401	201600021485
an	16	16	16
mois	2	4	10
jour	28	6	4
hrmn	1410	2130	1725
lumiere	1	5	1
agglomeration	2	2	2
intersection	1	2	1
meteo	8	1	1
collision	6	3	1
num_commune	5	112	229
adr	32, SALENGRO (AVENUE ROG	29, RUE DE LYON	21, CONCHES (ROUTE DE)
gps	M	M	M
lattitude	4.32996e+06	4.8848e+06	4.90226e+06
longitude	556934	237141	112371
dep	130	750	270
is_in_quart_d_heure	False	True	False
label_meteo	Temps couvert	Normale	Normale

4.2) group by / count / unique

#compter le nombdre d'accident par type de label météo
df.groupby("label_meteo")["Num_Acc"].count().sort_values()

label_meteo
Vent fort - tempête      144
Neige - grêle            159
Autre                    300
Brouillard - fumée       621
Temps éblouissant        667
Pluie forte             1422
Temps couvert           1640
Pluie légère            6582
Normale                47897
Name: Num_Acc, dtype: int64

# nombre d'accidents ? 
df.Num_Acc.count()

59432

#nombre d'accidents par heure de la journee
len(df.hrmn.unique())

1312

nb_de_minutes_par_jour = 60 * 24
nb_de_minutes_par_jour

1440

df.sample(3).T

	17373	30801	56064
Num_Acc	201600017374	201600030802	201600056065
an	16	16	16
mois	11	5	11
jour	30	4	20
hrmn	1500	1050	0045
lumiere	1	1	5
agglomeration	1	2	2
intersection	9	2	5
meteo	1	1	2
collision	7	1	3
num_commune	158	397	118
adr	NaN	KOUTIALA (BOULEVARD)	RUE DU POTEAU
gps	M	M	M
lattitude	4.70830e+06	4.84231e+06	4.88968e+06
longitude	251654	8090	233848
dep	180	610	750
is_in_quart_d_heure	True	False	True
label_meteo	Normale	Normale	Pluie légère

df.columns

Index(['Num_Acc', 'an', 'mois', 'jour', 'hrmn', 'lumiere', 'agglomeration',
       'intersection', 'meteo', 'collision', 'num_commune', 'adr', 'gps',
       'lattitude', 'longitude', 'dep', 'is_in_quart_d_heure', 'label_meteo'],
      dtype='object')

4.3) scatter plot : matplotlib / bokeh

# Matplotlib
df.plot.scatter(x="longitude", y="lattitude")

<AxesSubplot:xlabel='longitude', ylabel='lattitude'>

# Bokeh
p = figure()
p.circle(x="longitude", y="lattitude", source=df)
show(p)

5) Analyse des départements

df.dep.nunique()

101

# Nb d'accidents par département
df.groupby("dep")["Num_Acc"].count().sort_values()

dep
230      55
480      59
550      78
150      92
700      94
       ... 
940    2721
920    2873
930    3031
130    4110
750    6466
Name: Num_Acc, Length: 101, dtype: int64

# Création de deux colonnes "h" pour heure et "m" pour minute
# en s'appuyant sur un extrait de la colonne hrmn
df["h"] = df.hrmn.apply(lambda x: x[:2])
df["m"] = df.hrmn.apply(lambda x: x[2:])

La notion d'axis dans les dessins matplotlib

def despine_ax(ax):
    """
    Enlève les contours d'un axe dans une figure.
    """
    for spine in ax.spines.values():
        spine.set_visible(False)

title    = "Nombre d'accident par heure"
to_plot  = df.groupby("h")["Num_Acc"].count()
ax       = to_plot.plot.bar(title=title)
ax.hlines(to_plot.median(), 0, 24, colors="red", linestyles="dashed")
despine_ax(ax)
ax.fill_between(range(24), to_plot.quantile(0.25), to_plot.quantile(0.75), alpha=0.2)

<matplotlib.collections.PolyCollection at 0x1a7720aa2e0>

title    = "Nombre d'accident par heure"
to_plot  = df.groupby("h")["Num_Acc"].count()
ax       = to_plot.plot.bar(title=title)
ax.hlines(to_plot.median(), 0, 24, colors="red", linestyles="dashed")
ax.fill_between(range(24), to_plot.quantile(0.25), to_plot.quantile(0.75), alpha=0.2)

<matplotlib.collections.PolyCollection at 0x1a7721642e0>

5.1) Gestion des nuls

# Compter les nuls
df.adr.isnull().sum()

9169

df.adr.fillna("inconnu")

0              46, rue Sonneville
1             1a rue du cimetière
2                         inconnu
3              52 rue victor hugo
4                rue Joliot curie
                   ...           
59427    passamanty-Vahib‚ ( rout
59428     mamoudzou centre-Adrian
59429    kaweni-Kaweni sud  (Z I)
59430    kaweni-Kaweni nord ( Z I
59431    kaweni-Kaweni sud  (Z I)
Name: adr, Length: 59432, dtype: object

5.2) Regardons les départements

df.columns

Index(['Num_Acc', 'an', 'mois', 'jour', 'hrmn', 'lumiere', 'agglomeration',
       'intersection', 'meteo', 'collision', 'num_commune', 'adr', 'gps',
       'lattitude', 'longitude', 'dep', 'is_in_quart_d_heure', 'label_meteo',
       'h', 'm'],
      dtype='object')

# Nb d'accidents par détpartements
to_plot = df.groupby("dep")["Num_Acc"].count().sort_values()
to_plot.plot.barh(figsize=(5,15))

<matplotlib.axes._subplots.AxesSubplot at 0x235a43de610>

5.3) Tableau croisé dynamique

tab = df.pivot_table(index      = "dep", 
                     columns    = "h", 
                     values     = "Num_Acc", 
                     aggfunc    = "count",
                     fill_value = 0)

tab.sum(axis=1).sort_index().plot.bar()

<AxesSubplot:xlabel='dep'>

5.4) seaborn

import seaborn as sns

from matplotlib.colors import LogNorm

tab.max().max()

450

tab_sans_zero = tab.replace(0, 1)

idf = tab_sans_zero[tab_sans_zero.index.isin([770, 780, 910, 920, 930, 940, 950, 750])]

idf

h	00	01	02	03	04	05	06	07	08	09	...	14	15	16	17	18	19	20	21	22	23
dep
750	192	150	130	76	74	75	108	171	336	399	...	367	380	392	437	450	426	327	214	198	197
770	15	12	7	11	10	13	20	37	53	43	...	30	57	48	79	70	63	47	26	24	18
780	27	10	9	6	7	12	24	46	81	49	...	29	49	56	73	67	52	42	35	24	16
910	30	14	16	13	13	25	33	68	137	87	...	81	71	91	106	112	85	67	40	28	23
920	40	33	29	22	13	22	35	106	187	241	...	140	164	207	217	248	225	175	97	84	59
930	58	45	30	23	22	41	60	95	199	169	...	182	163	219	226	229	209	179	118	85	74
940	60	32	20	24	18	46	57	138	210	186	...	135	138	200	199	231	185	116	84	74	53
950	26	22	18	22	17	15	26	47	99	62	...	52	46	74	87	86	77	62	32	32	30

8 rows × 24 columns

province = tab_sans_zero[~tab_sans_zero.index.isin([770, 780, 910, 920, 930, 940, 950, 750])]
province

h	00	01	02	03	04	05	06	07	08	09	...	14	15	16	17	18	19	20	21	22	23
dep
10	6	8	3	7	5	11	8	15	22	16	...	19	32	29	41	31	19	16	15	13	11
20	8	5	3	1	3	4	4	6	15	13	...	9	10	9	22	21	14	4	3	3	8
30	6	1	1	1	2	6	4	9	9	11	...	12	12	14	22	20	9	12	2	5	7
40	4	3	4	3	1	1	3	1	7	2	...	14	11	19	15	16	4	2	3	4	2
50	2	2	1	1	1	1	1	5	6	6	...	8	6	8	15	5	5	3	5	3	1
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
971	9	7	5	6	3	12	14	19	15	15	...	16	12	20	17	24	16	21	14	15	14
972	10	8	4	4	5	8	18	10	14	14	...	22	17	21	15	21	20	20	12	7	7
973	10	2	6	4	2	7	11	38	37	19	...	24	31	32	35	20	35	32	29	21	12
974	13	12	3	12	4	14	27	31	19	19	...	27	29	45	33	36	37	28	17	15	17
976	1	1	1	2	2	6	11	15	12	11	...	14	10	11	15	14	9	10	2	6	3

93 rows × 24 columns

5.4.1) heatmap

title = "Accidents en province, échelle log"
norm=LogNorm(vmin=2, vmax=8000)
ax = sns.heatmap(province,norm=norm)
ax.set_title(title);

title = "Accidents en province,sans échelle log"
norm=LogNorm(vmin=2, vmax=8000)
ax = sns.heatmap(province)
ax.set_title(title);

title = "Accidents en île de france, échelle log"
norm=LogNorm(vmin=2, vmax=8000)
ax = sns.heatmap(idf,norm=norm)
ax.set_title(title);

title = "Accidents en île de france, sans échelle log"
norm=LogNorm(vmin=2, vmax=8000)
ax = sns.heatmap(idf)#,norm=norm)
ax.set_title(title);

!git add esilv_groupe_1_accidents_de_la_route.ipynb
!git commit -m "next"
!git push origin

fatal: not a git repository (or any of the parent directories): .git
fatal: not a git repository (or any of the parent directories): .git
fatal: not a git repository (or any of the parent directories): .git

Usage de jupyter notebook :

• Accès à la doc d'une fonction :
• 1) se mettre entre les parenthèses d'une fonction
• 2) MAJ + TAB

Manipuler les cellules => ESC + a ou b ou copier / coller / déplacer etc...

def startWithUnderscore(string:str):
    """
    Vérifie si la chaine de caractère commence par un underscore.
    
    Param:
        string: str
            Chaine de caractère à tester.
    
    Returns:
        Bool
        Commence ou non par un underscore.
    """
    if isinstance(string, str):
        return string.startswith("_")    
    else:
        return False

def testStartWithUnderscore():
    function = startWithUnderscore
    # test négatif
    local_input = "coucou"
    expected_output = False
    assert(function(local_input) == expected_output)
    # test positif
    local_input = "_coucou"
    expected_output = True
    assert(function(local_input) == expected_output)
    # test avec une entrée d'un autre type
    local_input = 1
    expected_output = False
    assert(function(local_input) == expected_output)

testStartWithUnderscore()

def startWithUnderscore(string):
    return string.startswith("_") if isinstance(string, str) else False

def doesntStartWithUnderscore(string):
    return not startWithUnderscore(string)

def is_df(x):
    return isinstance(x, pd.core.frame.DataFrame)

def is_var_df(var_name):
    return is_df(globals()[var_name])

Usage de jupyter notebook :

• Multi-cursor : ALT + click
• fin de ligne, début de ligne => CTRL + flèche droite ou gauche
• me déplacer d'un mot => CTRL + ALT + flèche droite ou gauche
• sélectionne => alt + maj + flèche droite / gauche

6) pickeliser les dataframes :

toutes_les_variables 	= locals()
noms_des_variables 		= list(toutes_les_variables.keys())
var_sans_underscore 	= list(filter(doesntStartWithUnderscore, noms_des_variables))
var_data_frame 			= filter(is_var_df,var_sans_underscore )

for nom_df in filter(is_var_df,var_sans_underscore ):
    print(nom_df)
    df           = locals()[nom_df]
    output_path  = "{nom_df}.pkl".format(nom_df=nom_df)
    df.to_pickle(output_path)

df
tab
tab_sans_zero
idf
province

7) Formattage des strings en python

=> ancienne mode => utiliser %s + un tuple de string

=> nouveau => utiliser des noms de variable entre accolades + la fonction format avec des paramétres qui sont ces noms de variables

7.1) Version historique : %S

"%s : %s"%("première string", "second string")

'première string : second string'

7.2) Les accolades + la fonction format

"{nom_var}_{bu}.pkl".format(nom_var=nom_df, bu="other")

'province_other.pkl'

# Les accolades + la fonction format
to_print = """
    {bu} : {CA:.10f}
    
""".format(nom_var=nom_df, bu="other", CA=1.2)

print(to_print)

    other : 1.2000000000
    

format_voulu = "{bu:%s} : {ca: >#09.4f}"%max_length_bu
format_voulu

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-73-81759294824c> in <module>
----> 1 format_voulu = "{bu:%s} : {ca: >#09.4f}"%max_length_bu
      2 format_voulu

NameError: name 'max_length_bu' is not defined

bus = {"cisco" : 10.345, "microsoft":30.34, "intel":500.0}
to_print = ""
max_length_bu = max(bus.keys())
for bu, ca in bus.items():
    ligne = format_voulu.format(bu=bu.capitalize(), ca=ca)
    print(ligne)

max_length_bu = max(map(lambda x: len(x), bus.keys()))
max_length_bu

7.3) f-strings

to_print = f"{max_length_bu}"
print(to_print)